home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / g / gnu_c / incl98.zoo / osbind.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-29  |  67.2 KB  |  2,192 lines
  1. /*
  2.  * osbind.h    bindings for OS traps
  3.  *
  4.  *        ++jrb bammi@cadence.com
  5.  */
  6.  
  7. /*
  8.  * majorly re-hacked for gcc-1.36 and probably beyond
  9.  * all inlines changed to #defines, beacuse gcc is not
  10.  * handling clobbered reggies correctly when -mshort.
  11.  * We now use the Statement Exprs feature of GnuC
  12.  *
  13.  * 10/12/89
  14.  *    changed all "g" constraints to "r" that will force
  15.  *    all operands to be evaluated (or lea calculated)
  16.  *    before the __asm__. This is necessary because
  17.  *    if we had the (looser) "g" constraint, then sometimes
  18.  *    we are in the situation where stuff is in the stack,
  19.  *    and we are modifying the stack under Gcc (but eventually
  20.  *    restoring it before the end of the __asm__), and it does
  21.  *    not know about it (i believe there is no way to tell it
  22.  *    this either, but you can hardly expect that). by forcing
  23.  *    the stricter "r" constraint, we force the eval before using
  24.  *    the val (or lea as the case may be) and we dont get into
  25.  *    trouble.
  26.  *    (thanks to ers for finding this problem!)
  27.  *    [one side effect of this is that we may(depending on the
  28.  *      situation) actually end up with better code when the
  29.  *    values are already in reggies, or that value is used
  30.  *    later on (note that Gnu's reggie allocation notices the
  31.  *    clobbered reggie, and does'nt put the value/or uses
  32.  *    them from those reggies, nice huh!)
  33.  *
  34.  *  28/2/90
  35.  *    another major re-hack:
  36.  *    -- the basic reason: there was just no reliable
  37.  *    way to get the definitions (inline or not does'nt matter) to
  38.  *    fully evaluate the args before we changed the sp from under it.
  39.  *    (if -fomit-frame-pointer is *not* used, then most of the time
  40.  *     we dont need to do this, as things will just reference off of
  41.  *     a6, but this is not true all of the time).
  42.  *    my solution was to use local vars in the body of the statement
  43.  *    exprs, and initialize them from the args of the statement expr block.
  44.  *    to force the evaluation of the args before we change sp from
  45.  *    under gcc's feet, we make the local vars volatile. we use a
  46.  *    slight code optimization heuristic: if there are more than 4
  47.  *    args, only then we make the local volatile, and relax
  48.  *    the "r" constraint to "g". otherwise, we dont put the volatile
  49.  *    and force the evaluation by putting the "r" constaint. this
  50.  *    produces better code in most sitiations (when !__NO_INLINE__
  51.  *    especially), as either the args are already in a register or
  52.  *    there is good chance they will soon be reused, and in that
  53.  *    case it will already be in a register.
  54.  *      it may (the local vars, especially when no volatile)
  55.  *    look like overhead, but in 99% of the situations gcc will just
  56.  *    optimize that assignment right out. besides, this makes
  57.  *    these defines totally safe (from re-evaluation of the macro args).
  58.  *
  59.  *    -- as suggested by andreas schwab (thanks!)
  60.  *     (schwab@ls5.informatik.uni-dortmund.de) all the retvalues are now
  61.  *     local register vals (see the extentions section in the info file)
  62.  *     this really worked out great as all the silly "movl d0,%0" at
  63.  *     the end of each def can now be removed, and the value of
  64.  *     retvalue ends up in the correct register. it avoids all the
  65.  *     silly "mov d0,[d|a]n" type sequences from being generated. a real win.
  66.  *     (note in the outputs "=r"(retvalue) still has to be specified,
  67.  *     otherwise in certain situations you end up loosing the return
  68.  *     value in d0, as gcc sees no output, and correctly assumes that the
  69.  *     asm returns no value).
  70.  *
  71.  *    -- all the n's (the function #'s for the traps) are now given
  72.  *    the more relaxed "g". This again results in better code, as
  73.  *    it is always a constant, and gcc turns the movw %1,sp@- into
  74.  *    a movw #n,sp@-. we could have given them a "i" constraint too,
  75.  *    but "g" gives gcc more breathing room, and it does the right
  76.  *    thing. note: the n's still need to have "r" constraints in the
  77.  *    non-inline form (function form), as they are no longer constants
  78.  *    in the function, but a normal arg on the stack frame, and hence
  79.  *    we need to force evaluation before we change sp. (see osbind.c)
  80.  *
  81.  *    -- straps.cpp and traps.c are history. we dont need no stinking
  82.  *    non-reentrant bindings (straps) or incorrect ones (traps.c :-)
  83.  *
  84.  * 03/15/92 ++jrb
  85.  *    -- another re-hack needed for gcc-2.0: the optimization that we
  86.  *      used earlier for traps with more than 4 args, making them volatile
  87.  *    and using "g" constraints no longer works, because gcc has become
  88.  *    so smart! we now remove the volatile, and give "r" constraints
  89.  *    (just like traps with <= 4 args). that way the args are evaled
  90.  *    before we change the stack under gcc, and at appropriate times
  91.  *    put into reggies and pushed (or as in most cases, they are evaled
  92.  *    straight into reggies and pushed -- and in even more common cases
  93.  *    they are already in reggies, and they are just pushed). not doing
  94.  *    this with -fomit-frame-pointer was causing the temps (from evaluing
  95.  *    the args) to be created on the stack, but when we changed sp
  96.  *    from under gccs feet, the offsets  to the temps ended up being wrong.
  97.  *
  98.  * 10/28/93 ++jrb
  99.  *    relax the constraints on the inputs of trap_14_wwwwwww (only
  100.  *    Rsconf maps to this)  to "g" from "r", as these many "r" 's
  101.  *    give gcc 2.>3.X heartaches (understandably). note this is ok
  102.  *    since these args will never be expressions, and we never
  103.  *    have to constrain hard enough to force eval before we change
  104.  *    sp from underneath gcc.
  105.  *
  106.  */
  107.  
  108. #ifndef _OSBIND_H
  109. #define _OSBIND_H
  110.  
  111. #ifndef _COMPILER_H
  112. #include <compiler.h>
  113. #endif
  114.  
  115. #ifdef __cplusplus
  116. extern "C" {
  117. #endif
  118.  
  119. #ifndef _OSTRUCT_H
  120. #include <ostruct.h>
  121. #endif
  122.  
  123. #ifdef __TURBOC__
  124.  
  125. /* we supply a library of bindings for TurboC / PureC */
  126.  
  127. long    gemdos( short, ... );
  128. long    bios( short, ... );
  129. long    xbios( short, ... );
  130.  
  131. /* Gemdos prototypes */
  132.  
  133. void    Pterm0( void );
  134. long    Cconin( void );
  135. void    Cconout( int c );
  136. int     Cauxin( void );
  137. void    Cauxout( int c );
  138. int     Cprnout( int c );
  139. long    Crawio( int w );
  140. long    Crawcin( void );
  141. long    Cnecin( void );
  142. int     Cconws( const char *buf );
  143. void    Cconrs( LINE *buf );
  144. int     Cconis( void );
  145. long    Dsetdrv( int drv );
  146. int     Cconos( void );
  147. int     Cprnos( void );
  148. int     Cauxis( void );
  149. int     Cauxos( void );
  150. int     Dgetdrv( void );
  151. void    Fsetdta( _DTA *buf );
  152. long    Super( void *stack );
  153. unsigned int  Tgetdate( void );
  154. unsigned int  Tsetdate( unsigned int date );
  155. unsigned int  Tgettime( void );
  156. unsigned int  Tsettime( unsigned int time );
  157. _DTA    *Fgetdta( void );
  158. int     Sversion( void );
  159. void    Ptermres( long keepcnt, int retcode );
  160. int     Dfree( _DISKINFO *buf, int driveno );
  161. int     Dcreate( const char *path );
  162. int     Ddelete( const char *path );
  163. int     Dsetpath( const char *path );
  164. long    Fcreate( const char *filename, int attr );
  165. long    Fopen( const char *filename, int mode );
  166. int     Fclose( int handle );
  167. long    Fread( int handle, long count, void *buf );
  168. long    Fwrite( int handle, long count, void *buf );
  169. int     Fdelete( const char *filename );
  170. long    Fseek( long offset, int handle, int seekmode );
  171. int     Fattrib( const char *filename, int wflag, int attrib );
  172. long    Fdup( int handle );
  173. long    Fforce( int stch, int nonstdh );
  174. int     Dgetpath( char *path, int driveno );
  175. void    *Malloc( long number );
  176. int     Mfree( void *block );
  177. int     Mshrink( int zero, void *ptr, long size );
  178. #define Mshrink(ptr, size) Mshrink(0, ptr, size)
  179. long    Pexec( int mode, char *ptr1, void *ptr2, void *ptr3 );
  180. void    Pterm( int retcode );
  181. int     Fsfirst( const char *filename, int attr );
  182. int     Fsnext( void );
  183. int     Frename( int zero, const char *oldname, const char *newname );
  184. int     Fdatime( _DOSTIME *timeptr, int handle, int wflag );
  185.  
  186. /* GEMDOS extensions */
  187.  
  188. void    *Mxalloc( long number, int mode );
  189. long    Maddalt( void *start, long size );
  190.  
  191. /* Network Gemdos Extension */
  192.  
  193. long    Flock( int handle, int mode, long start, long length );
  194.  
  195. /* BIOS */
  196.  
  197. void    Getmpb( _MPB *ptr );
  198. int     Bconstat( int dev );
  199. long    Bconin( int dev );
  200. long    Bconout( int dev, int c );
  201. long    Rwabs( int rwflag, void *buf, int cnt, int recnr, int dev );
  202. void    (*Setexc( int number, void (*exchdlr)() )) ();
  203. #define Setexc(number, exchdlr)    Setexc(number, (void(*)())(exchdlr))
  204. long    Tickcal( void );
  205. _BPB    *Getbpb( int dev );
  206. long    Bcostat( int dev );
  207. long    Mediach( int dev );
  208. long    Drvmap( void );
  209. long    Kbshift( int mode );
  210. #define Getshift() Kbshift(-1)
  211.  
  212. /* XBios */
  213.  
  214. void    Initmous( int type, _PARAM *par, void (*mousevec)() );
  215. #define Initmous(type, par, mousevec) Initmous(type, par, (void(*)()) mousevec)
  216. void    *Ssbrk( int count );
  217. void    *Physbase( void );
  218. void    *Logbase( void );
  219. int     Getrez( void );
  220. void    Setscreen( void *laddr, void *paddr, int rez );
  221. void    Setpalette( void *pallptr );
  222. int     Setcolor( int colornum, int color );
  223. int     Floprd( void *buf, long filler, int devno, int sectno,
  224.                int trackno, int sideno, int count );
  225. int     Flopwr( void *buf, long filler, int devno, int sectno,
  226.                int trackno, int sideno, int count );
  227. int     Flopfmt( void *buf, long filler, int devno, int spt, int trackno,
  228.                 int sideno, int interlv, long magic, int virgin );
  229. void    Midiws( int cnt, void *ptr );
  230. void    Mfpint( int erno, void (*vector)() );
  231. _IOREC   *Iorec( int dev );
  232. long    Rsconf( int baud, int ctr, int ucr, int rsr, int tsr, int scr );
  233. _KEYTAB  *Keytbl( void *unshift, void *shift, void *capslock );
  234. long    Random( void );
  235. void    Protobt( void *buf, long serialno, int disktype, int execflag );
  236. int     Flopver( void *buf, long filler, int devno, int sectno,
  237.                 int trackno, int sideno, int count );
  238. void    Scrdmp( void );
  239. int     Cursconf( int func, int rate );
  240. void    Settime( unsigned long time );
  241. unsigned long  Gettime( void );
  242. void    Bioskeys( void );
  243. void    Ikbdws( int count, void *ptr );
  244. void    Jdisint( int number );
  245. void    Jenabint( int number );
  246. char    Giaccess( char data, int regno );
  247. void    Offgibit( int bitno );
  248. void    Ongibit( int bitno );
  249. void    Xbtimer( int timer, int control, int data, void (*vector)() );
  250. void    *Dosound( void *buf );
  251. int     Setprt( int config );
  252. _KBDVECS *Kbdvbase( void );
  253. int     Kbrate( int initial, int repeat );
  254. void    Prtblk( _PBDEF *par );
  255. void    Vsync( void );
  256. long    Supexec( long (*func)() );
  257. #define Supexec(func) Supexec((long (*) ()) func)
  258. void    Puntaes( void );
  259. int     Floprate( int devno, int newrate );
  260. int     Blitmode( int mode );
  261.  
  262. /* TOS030 XBios */
  263. int     DMAread( long sector, int count, void *buffer, int devno );
  264. int     DMAwrite( long sector, int count, void *buffer, int devno );
  265. int     NVMaccess( int opcode, int start, int count, void *buffer );
  266. long    Bconmap( int devno );
  267. int     Esetshift( int shftMode );
  268. #define EsetShift Esetshift
  269. int     Egetshift( void );
  270. #define EgetShift Egetshift
  271. int     EsetBank( int bankNum );
  272. int     EsetColor( int colorNum, int color );
  273. void    EsetPalette( int colorNum, int count, int *palettePtr );
  274. void    EgetPalette( int colorNum, int count, int *palettePtr );
  275. int     EsetGray( int swtch );
  276. int     EsetSmear( int swtch );
  277.  
  278. #else /* !__TURBOC__ */
  279.  
  280. #ifdef __LATTICE__
  281.  
  282. /*
  283. *
  284. * GEMDOS inline bindings for Lattice C.
  285. *
  286. */
  287. void _vgv(int);
  288. unsigned short _ugv(int);
  289. int _igv(int);
  290. long _lgv(int);
  291. _DTA *_Dgv(int);
  292.  
  293. void _vgs(int,int);
  294. void _vgL(int,_CCONLINE *);
  295. void _vgD(int,_DTA *);
  296. int _igs(int,int);
  297. int _igu(int,unsigned short);
  298. int _igp(int,void *);
  299. int _igC(int,const char *);
  300. long _lgs(int,int);
  301. void *_pgl(int,long);
  302. void *_pgp(int,void *);
  303.  
  304. void _vgls(int,long,int);
  305. int _igss(int,int,int);
  306. int _igcs(int,char *,int);
  307. int _igCs(int,const char *,int);
  308. int _igIs(int,_DISKINFO *,int);
  309. int _igpl(int,void *,long);
  310. long _lgCs(int,const char *,int);
  311. void *_pgls(int,long,int);
  312.  
  313. short _sgCss(int,const char *,int,int);
  314. int _igspl(int,int,void *,long);
  315. int _igsCC(int,int,const char *,const char *);
  316. long _lgspl(int,int,void *,long);
  317. long _lgslp(int,int,long,void *);
  318. long _lgslP(int,int,long,const void *);
  319. long _lglss(int,long,int,int);
  320. long _lgTss(int,_DOSTIME *,int,int);
  321.  
  322. int _igsCpp(int,int,const char *,void *,void *);
  323. long _lgssll(int,int,int,long,long);
  324.  
  325. #pragma inline _vgv((short)) {register d2,a2; "4e41";}
  326. #pragma inline _vgs((short),(short)) {register d2,a2; "4e41";}
  327. #pragma inline _vgL((short),) {register d2,a2; "4e41";}
  328. #pragma inline _vgD((short),) {register d2,a2; "4e41";}
  329. #pragma inline d0=_igv((short)) {register d2,a2; "4e41";}
  330. #pragma inline d0=_igs((short),(short)) {register d2,a2; "4e41";}
  331. #pragma inline d0=_igu((short),) {register d2,a2; "4e41";}
  332. #pragma inline d0=_igp((short),) {register d2,a2; "4e41";}
  333. #pragma inline d0=_igC((short),) {register d2,a2; "4e41";}
  334. #pragma inline d0=_ugv((short)) {register d2,a2; "4e41";}
  335. #pragma inline d0=_lgv((short)) {register d2,a2; "4e41";}
  336. #pragma inline d0=_lgs((short),(short)) {register d2,a2; "4e41";}
  337. #pragma inline d0=_Dgv((short)) {register d2,a2; "4e41";}
  338. #pragma inline d0=_pgl((short),) {register d2,a2; "4e41";}
  339. #pragma inline d0=_pgp((short),) {register d2,a2; "4e41";}
  340.  
  341. #pragma inline d0=_igss((short),(short),(short)) {register d2,a2; "4e41";}
  342. #pragma inline d0=_igcs((short),,(short)) {register d2,a2; "4e41";}
  343. #pragma inline d0=_igCs((short),,(short)) {register d2,a2; "4e41";}
  344. #pragma inline d0=_igIs((short),,(short)) {register d2,a2; "4e41";}
  345. #pragma inline d0=_igpl((short),,) {register d2,a2; "4e41";}
  346. #pragma inline d0=_lgCs((short),,(short)) {register d2,a2; "4e41";}
  347.  
  348. #pragma inline d0=_pgls((short),,(short)) {register d2,a2; "4e41";}
  349.  
  350. #pragma inline d0=_sgCss((short),,(short),(short)) {register d2,a2; "4e41";}
  351. #pragma inline d0=_lgslp((short),(short),,) {register d2,a2; "4e41";}
  352. #pragma inline d0=_lgslP((short),(short),,) {register d2,a2; "4e41";}
  353. #pragma inline d0=_lgspl((short),(short),,) {register d2,a2; "4e41";}
  354. #pragma inline d0=_lglss((short),,(short),(short)) {register d2,a2; "4e41";}
  355. #pragma inline d0=_lgTss((short),,(short),(short)) {register d2,a2; "4e41";}
  356. #pragma inline d0=_igsCC((short),(short),,) {register d2,a2; "4e41";}
  357.  
  358. #pragma inline d0=_igsCpp((short),(short),,,) {register d2,a2; "4e41";}
  359.  
  360.  
  361. #define Pterm0()    _vgv(0)
  362. #define Cconin()    _lgv(1)
  363. #define Cconout(a)    _vgs(2,a)
  364. #define Cauxin()    _igv(3)
  365. #define Cauxout(a)    _vgs(4,a)
  366. #define Cprnout(a)    _igs(5,a)
  367. #define Crawio(a)    _lgs(6,a)
  368. #define Crawcin()    _lgv(7)
  369. #define Cnecin()    _lgv(8)
  370. #define Cconws(a)    _igC(9,a)
  371. #define Cconrs(a)    _vgL(10,a)
  372. #define Cconis()    _igv(11)
  373. #define Dsetdrv(a)    _lgs(14,a)
  374. #define Cconos()    _igv(16)
  375. #define Cprnos()    _igv(17)
  376. #define Cauxis()    _igv(18)
  377. #define Cauxos()    _igv(19)
  378. #define Dgetdrv()    _igv(25)
  379. #define Fsetdta(a)    _vgD(26,a)
  380. #define Super(a)    _pgp(32,a)
  381. #define Tgetdate()    _ugv(42)
  382. #define Tsetdate(a)    _igu(43,a)
  383. #define Tgettime()    _ugv(44)
  384. #define Tsettime(a)    _igu(45,a)
  385. #define Fgetdta()    _Dgv(47)
  386. #define Sversion()    _Vgv(48)
  387. #define Ptermres(a,b)    _vgls(49,a,b)
  388. #define Dfree(a,b)    _igIs(54,a,b)
  389. #define Dcreate(a)    _igC(57,a)
  390. #define Ddelete(a)    _igC(58,a)
  391. #define Dsetpath(a)    _igC(59,a)
  392. #define Fcreate(a,b)    _lgCs(60,a,b)
  393. #define Fopen(a,b)    _lgCs(61,a,b)
  394. #define Fclose(a)    _igs(62,a)
  395. #define Fread(a,b,c)    _lgslp(63,a,b,c)
  396. #define Fwrite(a,b,c)    _lgslP(64,a,b,c)
  397. #define Fdelete(a)    _igC(65,a)
  398. #define Fseek(a,b,c)    _lglss(66,a,b,c)
  399. #define Fattrib(a,b,c)    _sgCss(67,a,b,c)
  400. #define Fdup(a)        _lgs(69,a)
  401. #define Fforce(a,b)    _igss(70,a,b)
  402. #define Dgetpath(a,b)    _igcs(71,a,b)
  403. #define Malloc(a)    _pgl(72,a)
  404. #define Mfree(a)    _igp(73,a)
  405. #define Mshrink(a,b)    _lgspl(74,0,a,b)
  406. #define Pexec(a,b,c,d)    _igsCpp(75,a,b,c,d)
  407. #define Pterm(a)    _vgs(76,a)
  408. #define Fsfirst(a,b)    _igCs(78,a,b)
  409. #define Fsnext()    _igv(79)
  410. #define Frename(a,b,c)    _igsCC(86,a,b,c)
  411. #define Fdatime(a,b,c)    _lgTss(87,a,b,c)
  412.  
  413. #define Maddalt(a,b)    _igpl(20,a,b)
  414. #define Mxalloc(a,b)    _pgls(68,a,b)
  415.  
  416. /*
  417. *
  418. * Network GEMDOS, don't know the function numbers yet.
  419. *
  420. */
  421. /*
  422. #define Nversion() _lgv()
  423. #define Frlock(a,b,c) _lgsll(,a,b,c)
  424. #define Frunlock(a,b) _lgsl(,a,b)
  425. #define Flock(a,b) _lgsl(,a,b)
  426. #define Funlock(a) _lgs(,a)
  427. #define Fflush(a) _lgs(,a)
  428. #define Unlock() _lgC(,a)
  429. #define Lock() _lgC(,a)
  430. */
  431.  
  432. /*
  433. *
  434. * BIOS inline bindings for Lattice.
  435. *
  436. */
  437. long _lbv(int);
  438. unsigned long _Ubv(int);
  439.  
  440. void _vbM(int,_MPB *);
  441. int _ibs(int,int);
  442. long _lbs(int,int);
  443. _BPB *_Bbs(int,int);
  444.  
  445. int _ibss(int,int,int);
  446. void (*_FbsF(int,int,void (*)(void)))(void);
  447.  
  448. int _ibspsss(int,int,void *,int,int,int);
  449. int _ibspssl(int,int,void *,int,int,long);
  450.  
  451.  
  452. #pragma inline d0=_lbv((short)) {register d2,a2; "4e4d";}
  453. #pragma inline d0=_Ubv((short)) {register d2,a2; "4e4d";}
  454.  
  455. #pragma inline _vbM((short),) {register d2,a2; "4e4d";}
  456. #pragma inline d0=_ibs((short),(short)) {register d2,a2; "4e4d";}
  457. #pragma inline d0=_lbs((short),(short)) {register d2,a2; "4e4d";}
  458. #pragma inline d0=_Bbs((short),(short)) {register d2,a2; "4e4d";}
  459.  
  460. #pragma inline d0=_ibss((short),(short),(short)) {register d2,a2; "4e4d";}
  461. #pragma inline d0=_FbsF((short),(short),) {register d2,a2; "4e4d";}
  462.  
  463. #pragma inline d0=_ibsss((short),,(short),(short),(short)) {register d2,a2; "4e4d";}
  464. #pragma inline d0=_ibssl((short),,(short),(short),) {register d2,a2; "4e4d";}
  465.  
  466.  
  467. #define Getmpb(a)    _vbM(0,a)
  468. #define Bconstat(a)    _ibs(1,a)
  469. #define Bconin(a)    _lbs(2,a)
  470. #define Bconout(a,b)    _ibss(3,a,b)
  471. #define Rwabs(a,b,c,d,e)    _ibspsss(4,a,b,c,d,e)
  472. #define Setexc(a,b)    _FbsF(5,a,b)
  473. #define Tickcal()    _lbv(6)
  474. #define Getbpb(a)    _Bbs(7,a)
  475. #define Bcostat(a)    _ibs(8,a)
  476. #define Mediach(a)    _ibs(9,a)
  477. #define Drvmap()    _Ubv(10)
  478. #define Kbshift(a)    _lbs(11,a)
  479. #define Lrwabs(a,b,c,d,e)    _ibspssl(12,a,b,c,d,e)
  480.  
  481. /*
  482. *
  483. * XBIOS inline bindings for Lattice.
  484. *
  485. */
  486. void _vxv(int);
  487. short _sxv(int);
  488. int _ixv(int);
  489. long _lxv(int);
  490. void *_pxv(int);
  491. _DOSTIME _Txv(int);
  492. _KBDVECS *_Vxv(int);
  493.  
  494. void _vxs(int,int);
  495. void _vxr(int,unsigned short);
  496. void _vxC(int,const char *);
  497. void _vxT(int,_DOSTIME);
  498. short _sxs(int,int);
  499. short _sxQ(int,_PBDEF *);
  500. int _ixs(int,int);
  501. long _lxG(int,long (*)(void));
  502. void *_pxs(int,int);
  503. _IOREC *_Ixs(int,int);
  504. long _Bxs(int,int);
  505.  
  506. void _vxsC(int,int,const char *);
  507. void _vxsF(int,int,void (*)(void));
  508. short _sxss(int,int,int);
  509. int _ixss(int,int,int);
  510.  
  511. void _vxsMF(int,int,_PARAM *,void (*)(void));
  512. void _vxpps(int,void *,void *,int);
  513. void _vxssq(int,int,int,short *);
  514. void _vxssQ(int,int,int,const short *);
  515. _KEYTAB *_KxCCC(int,const char *,const char *,const char *);
  516.  
  517. void _vxplss(int,void *,long,int,int);
  518. void _vxsssF(int,int,int,int,void (*)(void));
  519. int _ixsssc(int,int,int,int,char *);
  520. int _ixlsps(int,long,int,void *,int);
  521. int _ixlsPs(int,long,int,const void *,int);
  522.  
  523. long _lxssssss(int,int,int,int,int,int,int);
  524.  
  525. short _sxplsssss(int,void *,long,int,int,int,int,int);
  526. short _sxPlsssss(int,const void *,long,int,int,int,int,int);
  527.  
  528. short _sxprsssssls(int,void *,short *,int,int,int,int,int,long,int);
  529.  
  530.  
  531. #pragma inline _vxv((short)) {register d2,a2; "4e4e";}
  532. #pragma inline d0=_sxv((short)) {register d2,a2; "4e4e";}
  533. #pragma inline d0=_ixv((short)) {register d2,a2; "4e4e";}
  534. #pragma inline d0=_lxv((short)) {register d2,a2; "4e4e";}
  535. #pragma inline d0=_pxv((short)) {register d2,a2; "4e4e";}
  536. #pragma inline d0=_Txv((short)) {register d2,a2; "4e4e";}
  537. #pragma inline d0=_Vxv((short)) {register d2,a2; "4e4e";}
  538.  
  539. #pragma inline _vxs((short),(short)) {register d2,a2; "4e4e";}
  540. #pragma inline _vxr((short),) {register d2,a2; "4e4e";}
  541. #pragma inline _vxC((short),) {register d2,a2; "4e4e";}
  542. #pragma inline _vxT((short),) {register d2,a2; "4e4e";}
  543. #pragma inline d0=_sxs((short),(short)) {register d2,a2; "4e4e";}
  544. #pragma inline d0=_sxQ((short),) {register d2,a2; "4e4e";}
  545. #pragma inline d0=_ixs((short),(short)) {register d2,a2; "4e4e";}
  546. #pragma inline d0=_lxG((short),) {register d2,a2; "4e4e";}
  547. #pragma inline d0=_pxs((short),(short)) {register d2,a2; "4e4e";}
  548. #pragma inline d0=_Ixs((short),(short)) {register d2,a2; "4e4e";}
  549. #pragma inline d0=_Bxs((short),(short)) {register d2,a2; "4e4e";}
  550.  
  551. #pragma inline _vxsC((short),(short),) {register d2,a2; "4e4e";}
  552. #pragma inline _vxsF((short),(short),) {register d2,a2; "4e4e";}
  553. #pragma inline d0=_sxss((short),(short),(short)) {register d2,a2; "4e4e";}
  554. #pragma inline d0=_ixss((short),(short),(short)) {register d2,a2; "4e4e";}
  555.  
  556. #pragma inline _vxsMF((short),(short),,) {register d2,a2; "4e4e";}
  557. #pragma inline _vxpps((short),,,(short)) {register d2,a2; "4e4e";}
  558. #pragma inline _vxssq((short),(short),(short),) {register d2,a2; "4e4e";}
  559. #pragma inline _vxssQ((short),(short),(short),) {register d2,a2; "4e4e";}
  560. #pragma inline d0=_KxCCC((short),,,) {register d2,a2; "4e4e";}
  561.  
  562. #pragma inline _vxplss((short),,,(short),(short)) {register d2,a2; "4e4e";}
  563. #pragma inline _vxsssF((short),(short),(short),(short),) {register d2,a2; "4e4e";}
  564. #pragma inline d0=_ixsssc((short),(short),(short),(short),) {register d2,a2; "4e4e";}
  565. #pragma inline d0=_ixlsps((short),,(short),,(short)) {register d2,a2; "4e4e";}
  566. #pragma inline d0=_ixlsPs((short),,(short),,(short)) {register d2,a2; "4e4e";}
  567.  
  568. #pragma inline d0=_lxssssss((short),(short),(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  569.  
  570. #pragma inline d0=_sxplsssss((short),,,(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  571. #pragma inline d0=_sxPlsssss((short),,,(short),(short),(short),(short),(short)) {register d2,a2; "4e4e";}
  572.  
  573. #pragma inline d0=_sxprsssssls((short),,,(short),(short),(short),(short),(short),,(short)) {register d2,a2; "4e4e";}
  574.  
  575.  
  576. #define Initmous(a,b,c)    _vxsMF(0,a,b,c)
  577. #define Ssbrk(a)    _pxs(1,a)
  578. #define Physbase()    _pxv(2)
  579. #define Logbase()    _pxv(3)
  580. #define Getrez()    _sxv(4)
  581. #define Setscreen(a,b,c)    _vxpps(5,a,b,c)
  582. #define Setpallete(a)    _vxr(6,a)
  583. #define setcolor(a,b)    _sxss(7,a,b)
  584. #define Floprd(a,b,c,d,e,f,g)    _sxplsssss(8,a,b,c,d,e,f,g)
  585. #define Flopwr(a,b,c,d,e,f,g)    _sxPlsssss(9,a,b,c,d,e,f,g)
  586. #define Flopfmt(a,b,c,d,e,f,g,h,i)    _sxprsssssls(10,a,b,c,d,e,f,g,h,i)
  587. #define Midiws(a,b)    _vxsC(12,a,b)
  588. #define Mfpint(a,b)    _vxsF(13,a,b)
  589. #define Iorec(a)    _Ixs(14,a)
  590. #define Rsconf(a,b,c,d,e,f)    _lxssssss(15,a,b,c,d,e,f)
  591. #define Keytbl(a,b,c)    _KxCCC(16,a,b,c)
  592. #define Random()    _lxv(17)
  593. #define Protobt(a,b,c,d)    _vxplss(18,a,b,c,d)
  594. #define Flopver(a,b,c,d,e,f,g)    _sxplsssss(19,a,b,c,d,e,f,g)
  595. #define Scrdmp()    _vxv(20)
  596. #define Cursconf(a,b)    _sxss(21,a,b)
  597. #define Settime(a)    _vxT(22,a)
  598. #define Gettime()    _Txv(23)
  599. #define Bioskeys()    _vxv(24)
  600. #define Ikbdws(a,b)    _vxsC(25,a,b)
  601. #define Jdisint(a)    _vxs(26,a)
  602. #define Jenabint(a)    _vxs(27,a)
  603. #define Giaccess(a,b)    _sxss(28,a,b)
  604. #define Offgibit(a)    _vxs(29,a)
  605. #define Ongibit(a)    _vxs(30,a)
  606. #define Xbtimer(a,b,c,d)    _vxsssF(31,a,b,c,d)
  607. #define Dosound(a)    _vxC(32,a)
  608. #define Setprt(a)    _sxs(33,a)
  609. #define Kbdvbase()    _Vxv(34)
  610. #define Kbrate(a,b)    _sxss(35,a,b)
  611. #define Prtblk(a)    _sxQ(36,a)
  612. #define Vsync()    _vxv(37)
  613. #define Supexec(a)    _lxG(38,a)
  614. #define Puntaes()    _vxv(39)
  615.  
  616. #define Blitmode(a)    _sxs(64,a)
  617.  
  618. #define Floprate(a,b)    _sxss(41,a,b)
  619.  
  620. #define DMAread(a,b,c,d)    _ixlsps(42,a,b,c,d)
  621. #define DMAwrite(a,b,c,d)    _ixlsPs(43,a,b,c,d)
  622. #define Bconmap(a)    _Bxs(44,a)
  623. #define NVMaccess(a,b,c,d)    _ixsssc(46,a,b,c,d)
  624.  
  625. #define EsetShift(a)    _ixs(80,a)
  626. #define EgetShift()    _ixv(81)
  627. #define EsetBank(a)    _ixs(82,a)
  628. #define EsetColor(a,b)    _ixss(83,a,b)
  629. #define EsetPalette(a,b,c)    _vxssQ(84,a,b,c)
  630. #define EgetPalette(a,b,c)    _vxssq(85,a,b,c)
  631. #define EsetGray(a)    _ixs(86,a)
  632. #define EsetSmear(a)    _ixs(87,a)
  633.  
  634. #else /* !__LATTICE__ */
  635.  
  636. /* want to skip all the gory details of GNU C inlines??
  637.    search for the string "DEFINITIONS" */
  638.  
  639. #ifdef __GNUC_INLINE__
  640. /*
  641.  * GNU C (pseudo inline) Statement Exprs for traps
  642.  *
  643.  */
  644.  
  645. #if __GNUC__ > 1
  646. #define AND_MEMORY , "memory"
  647. #else
  648. #define AND_MEMORY
  649. #define __extension__
  650. #endif
  651.  
  652. #define trap_1_w(n)                            \
  653. __extension__                                \
  654. ({                                    \
  655.     register long retvalue __asm__("d0");                \
  656.                                         \
  657.     __asm__ volatile                        \
  658.     ("\
  659.         movw    %1,sp@-; \
  660.         trap    #1;    \
  661.         addqw   #2,sp "                        \
  662.     : "=r"(retvalue)            /* outputs */        \
  663.     : "g"(n)                /* inputs  */        \
  664.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  665.       AND_MEMORY                            \
  666.     );                                \
  667.     retvalue;                            \
  668. })
  669.  
  670. #define trap_1_ww(n, a)                            \
  671. __extension__                                \
  672. ({                                    \
  673.     register long retvalue __asm__("d0");                \
  674.     short _a = (short)(a);                        \
  675.                                         \
  676.     __asm__ volatile                        \
  677.     ("\
  678.         movw    %2,sp@-; \
  679.         movw    %1,sp@-; \
  680.         trap    #1;    \
  681.         addqw   #4,sp "                        \
  682.     : "=r"(retvalue)            /* outputs */        \
  683.     : "g"(n), "r"(_a)            /* inputs  */        \
  684.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  685.       AND_MEMORY                            \
  686.     );                                \
  687.     retvalue;                            \
  688. })
  689.  
  690. #define trap_1_wl(n, a)                            \
  691. __extension__                                \
  692. ({                                    \
  693.     register long retvalue __asm__("d0");                \
  694.     long  _a = (long) (a);                        \
  695.                                         \
  696.     __asm__ volatile                        \
  697.     ("\
  698.         movl    %2,sp@-; \
  699.         movw    %1,sp@-; \
  700.         trap    #1;    \
  701.         addqw   #6,sp "                        \
  702.     : "=r"(retvalue)            /* outputs */        \
  703.     : "g"(n), "r"(_a)            /* inputs  */        \
  704.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  705.       AND_MEMORY                            \
  706.     );                                \
  707.     retvalue;                            \
  708. })
  709.  
  710. #define trap_1_wlw(n, a, b)                        \
  711. __extension__                                \
  712. ({                                    \
  713.     register long retvalue __asm__("d0");                \
  714.     long  _a = (long) (a);                        \
  715.     short _b = (short)(b);                        \
  716.                                         \
  717.     __asm__ volatile                        \
  718.     ("\
  719.         movw    %3,sp@-; \
  720.         movl    %2,sp@-; \
  721.         movw    %1,sp@-; \
  722.         trap    #1;    \
  723.         addqw   #8,sp "                        \
  724.     : "=r"(retvalue)            /* outputs */        \
  725.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  726.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  727.       AND_MEMORY                            \
  728.     );                                \
  729.     retvalue;                            \
  730. })
  731.  
  732. #define trap_1_wwll(n, a, b, c)                        \
  733. __extension__                                \
  734. ({                                    \
  735.     register long retvalue __asm__("d0");                \
  736.     short _a = (short)(a);                        \
  737.     long  _b = (long) (b);                        \
  738.     long  _c = (long) (c);                        \
  739.                                         \
  740.     __asm__ volatile                        \
  741.     ("\
  742.         movl    %4,sp@-; \
  743.         movl    %3,sp@-; \
  744.         movw    %2,sp@-; \
  745.         movw    %1,sp@-; \
  746.         trap    #1;    \
  747.         lea    sp@(12),sp "                    \
  748.     : "=r"(retvalue)            /* outputs */        \
  749.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  750.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  751.       AND_MEMORY                            \
  752.     );                                \
  753.     retvalue;                            \
  754. })
  755.  
  756. #define trap_1_wlww(n, a, b, c)                        \
  757. __extension__                                \
  758. ({                                    \
  759.     register long retvalue __asm__("d0");                \
  760.     long  _a = (long) (a);                        \
  761.     short _b = (short)(b);                        \
  762.     short _c = (short)(c);                        \
  763.                                         \
  764.     __asm__ volatile                        \
  765.     ("\
  766.         movw    %4,sp@-; \
  767.         movw    %3,sp@-; \
  768.         movl    %2,sp@-; \
  769.         movw    %1,sp@-; \
  770.         trap    #1;    \
  771.         lea    sp@(10),sp "                    \
  772.     : "=r"(retvalue)            /* outputs */        \
  773.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  774.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  775.       AND_MEMORY                            \
  776.     );                                \
  777.     retvalue;                            \
  778. })
  779.  
  780. #define trap_1_www(n, a, b)                        \
  781. __extension__                                \
  782. ({                                    \
  783.     register long retvalue __asm__("d0");                \
  784.     short _a = (short)(a);                        \
  785.     short _b = (short)(b);                        \
  786.                                         \
  787.     __asm__ volatile                        \
  788.     ("\
  789.         movw    %3,sp@-; \
  790.         movw    %2,sp@-; \
  791.         movw    %1,sp@-; \
  792.         trap    #1;    \
  793.         addqw   #6,sp "                        \
  794.     : "=r"(retvalue)            /* outputs */        \
  795.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  796.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  797.       AND_MEMORY                            \
  798.     );                                \
  799.     retvalue;                            \
  800. })
  801.  
  802. #define trap_1_wll(n, a, b)                        \
  803. __extension__                                \
  804. ({                                    \
  805.     register long retvalue __asm__("d0");                \
  806.     long  _a = (long) (a);                        \
  807.     long  _b = (long) (b);                        \
  808.                                         \
  809.     __asm__ volatile                        \
  810.     ("\
  811.         movl    %3,sp@-; \
  812.         movl    %2,sp@-; \
  813.         movw    %1,sp@-; \
  814.         trap    #1;    \
  815.         lea    sp@(10),sp "                    \
  816.     : "=r"(retvalue)            /* outputs */        \
  817.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  818.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  819.       AND_MEMORY                            \
  820.     );                                \
  821.     retvalue;                            \
  822. })
  823.  
  824. #if __GNUC__ > 1
  825. #define trap_1_wwlll(n, a, b, c, d)                    \
  826. __extension__                                \
  827. ({                                    \
  828.     register long retvalue __asm__("d0");                \
  829.     short _a = (short)(a);            \
  830.     long  _b = (long) (b);            \
  831.     long  _c = (long) (c);            \
  832.     long  _d = (long) (d);            \
  833.                                         \
  834.     __asm__ volatile                        \
  835.     ("\
  836.         movl    %5,sp@-; \
  837.         movl    %4,sp@-; \
  838.         movl    %3,sp@-; \
  839.         movw    %2,sp@-; \
  840.         movw    %1,sp@-; \
  841.         trap    #1;    \
  842.         lea    sp@(16),sp "                    \
  843.     : "=r"(retvalue)            /* outputs */        \
  844.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  845.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  846.     );                                \
  847.     retvalue;                            \
  848. })
  849.  
  850. #define trap_1_wwwll(n, a, b, c, d)                    \
  851. __extension__                                \
  852. ({                                    \
  853.     register long retvalue __asm__("d0");                \
  854.     short _a = (short)(a);                        \
  855.     short _b = (short)(b);                        \
  856.     long  _c = (long) (c);                        \
  857.     long  _d = (long) (d);                        \
  858.                                         \
  859.     __asm__ volatile                        \
  860.     ("\
  861.         movl    %5,sp@-; \
  862.         movl    %4,sp@-; \
  863.         movw    %3,sp@-; \
  864.         movw    %2,sp@-; \
  865.         movw    %1,sp@-; \
  866.         trap    #1;    \
  867.         lea    sp@(14),sp "                    \
  868.     : "=r"(retvalue)            /* outputs */        \
  869.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  870.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  871.     );                                \
  872.     retvalue;                            \
  873. })
  874. #else
  875. #define trap_1_wwlll(n, a, b, c, d)                    \
  876. ({                                    \
  877.     register long retvalue __asm__("d0");                \
  878.     short _a = (short)(a);            \
  879.     long  _b = (long) (b);            \
  880.     long  _c = (long) (c);            \
  881.     long  _d = (long) (d);            \
  882.                                         \
  883.     __asm__ volatile                        \
  884.     ("\
  885.         movl    %4,sp@-; \
  886.         movl    %3,sp@-; \
  887.         movl    %2,sp@-; \
  888.         movw    %1,sp@-; \
  889.         movw    %0,sp@- "                    \
  890.     :                         /* outputs */    \
  891.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  892.         );                                \
  893.   /* no more than 5 operand allowed in asm() -- therefore the split */  \
  894.                                     \
  895.     __asm__ volatile                        \
  896.     ("\
  897.         trap    #1;    \
  898.         lea    sp@(16),sp "                    \
  899.     : "=r"(retvalue)            /* outputs */        \
  900.     :                    /* inputs  */        \
  901.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  902.     );                                \
  903.     retvalue;                            \
  904. })
  905.  
  906. #define trap_1_wwwll(n, a, b, c, d)                    \
  907. ({                                    \
  908.     register long retvalue __asm__("d0");                \
  909.     short _a = (short)(a);                        \
  910.     short _b = (short)(b);                        \
  911.     long  _c = (long) (c);                        \
  912.     long  _d = (long) (d);                        \
  913.                                         \
  914.     __asm__ volatile                        \
  915.     ("\
  916.         movl    %4,sp@-; \
  917.         movl    %3,sp@-; \
  918.         movw    %2,sp@-; \
  919.         movw    %1,sp@-; \
  920.         movw    %0,sp@- "                    \
  921.     :                         /* outputs */    \
  922.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  923.         );                                \
  924.                                     \
  925.     __asm__ volatile                        \
  926.     ("\
  927.         trap    #1;    \
  928.         lea    sp@(16),sp "                    \
  929.     : "=r"(retvalue)            /* outputs */        \
  930.     :                    /* inputs  */        \
  931.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  932.     );                                \
  933.     retvalue;                            \
  934. })
  935. #endif
  936.  
  937. #define trap_13_wl(n, a)                        \
  938. __extension__                                \
  939. ({                                    \
  940.     register long retvalue __asm__("d0");                \
  941.     long  _a = (long) (a);                        \
  942.                                         \
  943.     __asm__ volatile                        \
  944.     ("\
  945.         movl    %2,sp@-; \
  946.         movw    %1,sp@-; \
  947.         trap    #13;    \
  948.         addqw   #6,sp "                        \
  949.     : "=r"(retvalue)            /* outputs */        \
  950.     : "g"(n), "r"(_a)            /* inputs  */        \
  951.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  952.       AND_MEMORY                            \
  953.     );                                \
  954.     retvalue;                            \
  955. })
  956.  
  957. #define trap_13_w(n)                            \
  958. __extension__                                \
  959. ({                                    \
  960.     register long retvalue __asm__("d0");                \
  961.                                         \
  962.     __asm__ volatile                        \
  963.     ("\
  964.         movw    %1,sp@-; \
  965.         trap    #13;    \
  966.         addqw   #2,sp "                        \
  967.     : "=r"(retvalue)            /* outputs */        \
  968.     : "g"(n)                /* inputs  */        \
  969.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  970.       AND_MEMORY                            \
  971.     );                                \
  972.     retvalue;                            \
  973. })
  974.  
  975. #define trap_13_ww(n, a)                        \
  976. __extension__                                \
  977. ({                                    \
  978.     register long retvalue __asm__("d0");                \
  979.     short _a = (short)(a);                        \
  980.                                         \
  981.     __asm__ volatile                        \
  982.     ("\
  983.         movw    %2,sp@-; \
  984.         movw    %1,sp@-; \
  985.         trap    #13;    \
  986.         addqw   #4,sp "                        \
  987.     : "=r"(retvalue)            /* outputs */        \
  988.     : "g"(n), "r"(_a)            /* inputs  */        \
  989.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  990.       AND_MEMORY                            \
  991.     );                                \
  992.     retvalue;                            \
  993. })
  994.  
  995. #define trap_13_www(n, a, b)                        \
  996. __extension__                                \
  997. ({                                    \
  998.     register long retvalue __asm__("d0");                \
  999.     short _a = (short)(a);                        \
  1000.     short _b = (short)(b);                        \
  1001.                                         \
  1002.     __asm__ volatile                        \
  1003.     ("\
  1004.         movw    %3,sp@-; \
  1005.         movw    %2,sp@-; \
  1006.         movw    %1,sp@-; \
  1007.         trap    #13;    \
  1008.         addqw   #6,sp "                        \
  1009.     : "=r"(retvalue)            /* outputs */        \
  1010.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1011.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1012.       AND_MEMORY                            \
  1013.     );                                \
  1014.     retvalue;                            \
  1015. })
  1016.  
  1017. #if __GNUC__ > 1
  1018. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  1019. __extension__                                \
  1020. ({                                    \
  1021.     register long retvalue __asm__("d0");                \
  1022.     short _a = (short)(a);            \
  1023.     long  _b = (long) (b);            \
  1024.     short _c = (short)(c);            \
  1025.     short _d = (short)(d);            \
  1026.     short _e = (short)(e);            \
  1027.                                         \
  1028.     __asm__ volatile                        \
  1029.     ("\
  1030.         movw    %6,sp@-; \
  1031.         movw    %5,sp@-; \
  1032.         movw    %4,sp@-; \
  1033.         movl    %3,sp@-; \
  1034.         movw    %2,sp@-; \
  1035.         movw    %1,sp@-; \
  1036.         trap    #13;    \
  1037.         lea    sp@(14),sp "                    \
  1038.     : "=r"(retvalue)            /* outputs */        \
  1039.     : "g"(n),                            \
  1040.       "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */    \
  1041.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1042.     );                                \
  1043.     retvalue;                            \
  1044. })
  1045. #else
  1046. #define trap_13_wwlwww(n, a, b, c, d, e)                \
  1047. ({                                    \
  1048.     register long retvalue __asm__("d0");                \
  1049.     short _a = (short)(a);            \
  1050.     long  _b = (long) (b);            \
  1051.     short _c = (short)(c);            \
  1052.     short _d = (short)(d);            \
  1053.     short _e = (short)(e);            \
  1054.                                         \
  1055.     __asm__ volatile                        \
  1056.     ("\
  1057.         movw    %4,sp@-; \
  1058.         movw    %3,sp@-; \
  1059.         movw    %2,sp@-; \
  1060.         movl    %1,sp@-; \
  1061.         movw    %0,sp@-    "                    \
  1062.     :                          /* outputs */    \
  1063.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d), "r"(_e) /* inputs  */    \
  1064.     );                                \
  1065.                                     \
  1066.     __asm__ volatile                        \
  1067.     ("\
  1068.         movw    %1,sp@-; \
  1069.         trap    #13;    \
  1070.         lea    sp@(14),sp "                    \
  1071.     : "=r"(retvalue)            /* outputs */        \
  1072.     : "g"(n)                /* inputs  */        \
  1073.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1074.     );                                \
  1075.     retvalue;                            \
  1076. })
  1077. #endif
  1078.  
  1079. #define trap_13_wwl(n, a, b)                        \
  1080. __extension__                                \
  1081. ({                                    \
  1082.     register long retvalue __asm__("d0");                \
  1083.     short _a = (short)(a);                        \
  1084.     long  _b = (long) (b);                        \
  1085.                                         \
  1086.     __asm__ volatile                        \
  1087.     ("\
  1088.         movl    %3,sp@-; \
  1089.         movw    %2,sp@-; \
  1090.         movw    %1,sp@-; \
  1091.         trap    #13;    \
  1092.         addqw   #8,sp "                        \
  1093.     : "=r"(retvalue)            /* outputs */        \
  1094.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1095.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1096.       AND_MEMORY                            \
  1097.     );                                \
  1098.     retvalue;                            \
  1099. })
  1100.  
  1101. #define trap_14_wwl(n, a, b)                        \
  1102. __extension__                                \
  1103. ({                                    \
  1104.     register long retvalue __asm__("d0");                \
  1105.     short _a = (short)(a);                        \
  1106.     long  _b = (long) (b);                        \
  1107.                                         \
  1108.     __asm__ volatile                        \
  1109.     ("\
  1110.         movl    %3,sp@-; \
  1111.         movw    %2,sp@-; \
  1112.         movw    %1,sp@-; \
  1113.         trap    #14;    \
  1114.         addqw   #8,sp "                        \
  1115.     : "=r"(retvalue)            /* outputs */        \
  1116.     : "g"(n), "r"(_a), "r"(_b)              /* inputs  */        \
  1117.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1118.       AND_MEMORY                            \
  1119.     );                                \
  1120.     retvalue;                            \
  1121. })
  1122.  
  1123. #define trap_14_wwll(n, a, b, c)                    \
  1124. __extension__                                \
  1125. ({                                    \
  1126.     register long retvalue __asm__("d0");                \
  1127.     short _a = (short)(a);                        \
  1128.     long  _b = (long) (b);                        \
  1129.     long  _c = (long) (c);                        \
  1130.                                         \
  1131.     __asm__ volatile                        \
  1132.     ("\
  1133.         movl    %4,sp@-; \
  1134.         movl    %3,sp@-; \
  1135.         movw    %2,sp@-; \
  1136.         movw    %1,sp@-; \
  1137.         trap    #14;    \
  1138.         lea    sp@(12),sp "                    \
  1139.     : "=r"(retvalue)            /* outputs */        \
  1140.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  1141.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1142.       AND_MEMORY                            \
  1143.     );                                \
  1144.     retvalue;                            \
  1145. })
  1146.  
  1147. #define trap_14_ww(n, a)                        \
  1148. __extension__                                \
  1149. ({                                    \
  1150.     register long retvalue __asm__("d0");                \
  1151.     short _a = (short)(a);                        \
  1152.                                         \
  1153.     __asm__ volatile                        \
  1154.     ("\
  1155.         movw    %2,sp@-; \
  1156.         movw    %1,sp@-; \
  1157.         trap    #14;    \
  1158.         addqw   #4,sp "                        \
  1159.     : "=r"(retvalue)            /* outputs */        \
  1160.     : "g"(n), "r"(_a)            /* inputs  */        \
  1161.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1162.       AND_MEMORY                            \
  1163.     );                                \
  1164.     retvalue;                            \
  1165. })
  1166.  
  1167. #define trap_14_w(n)                            \
  1168. __extension__                                \
  1169. ({                                    \
  1170.     register long retvalue __asm__("d0");                \
  1171.                                         \
  1172.     __asm__ volatile                        \
  1173.     ("\
  1174.         movw    %1,sp@-; \
  1175.         trap    #14;    \
  1176.         addqw   #2,sp "                        \
  1177.     : "=r"(retvalue)            /* outputs */        \
  1178.     : "g"(n)                /* inputs  */        \
  1179.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1180.       AND_MEMORY                            \
  1181.     );                                \
  1182.     retvalue;                            \
  1183. })
  1184.  
  1185. #define trap_14_wllw(n, a, b, c)                    \
  1186. __extension__                                \
  1187. ({                                    \
  1188.     register long retvalue __asm__("d0");                \
  1189.     long  _a = (long) (a);                        \
  1190.     long  _b = (long) (b);                        \
  1191.     short _c = (short)(c);                        \
  1192.                                         \
  1193.     __asm__ volatile                        \
  1194.     ("\
  1195.         movw    %4,sp@-; \
  1196.         movl    %3,sp@-; \
  1197.         movl    %2,sp@-; \
  1198.         movw    %1,sp@-; \
  1199.         trap    #14;    \
  1200.         lea    sp@(12),sp "                    \
  1201.     : "=r"(retvalue)            /* outputs */        \
  1202.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)       /* inputs  */        \
  1203.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1204.       AND_MEMORY                            \
  1205.     );                                \
  1206.     retvalue;                            \
  1207. })
  1208.  
  1209. #define trap_14_wl(n, a)                        \
  1210. __extension__                                \
  1211. ({                                    \
  1212.     register long retvalue __asm__("d0");                \
  1213.     long  _a = (long) (a);                        \
  1214.                                         \
  1215.     __asm__ volatile                        \
  1216.     ("\
  1217.         movl    %2,sp@-; \
  1218.         movw    %1,sp@-; \
  1219.         trap    #14;    \
  1220.         addqw   #6,sp "                        \
  1221.     : "=r"(retvalue)            /* outputs */        \
  1222.     : "g"(n), "r"(_a)            /* inputs  */        \
  1223.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1224.       AND_MEMORY                            \
  1225.     );                                \
  1226.     retvalue;                            \
  1227. })
  1228.  
  1229. #define trap_14_www(n, a, b)                        \
  1230. __extension__                                \
  1231. ({                                    \
  1232.     register long retvalue __asm__("d0");                \
  1233.     short _a = (short)(a);                        \
  1234.     short _b = (short)(b);                        \
  1235.                                         \
  1236.     __asm__ volatile                        \
  1237.     ("\
  1238.         movw    %3,sp@-; \
  1239.         movw    %2,sp@-; \
  1240.         movw    %1,sp@-; \
  1241.         trap    #14;    \
  1242.         addqw   #6,sp "                        \
  1243.     : "=r"(retvalue)            /* outputs */        \
  1244.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1245.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1246.       AND_MEMORY                            \
  1247.     );                                \
  1248.     retvalue;                            \
  1249. })
  1250.  
  1251. #if __GNUC__ > 1
  1252. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  1253. __extension__                                \
  1254. ({                                    \
  1255.     register long retvalue __asm__("d0");                \
  1256.     long  _a = (long) (a);                        \
  1257.     long  _b = (long) (b);                        \
  1258.     short _c = (short)(c);                        \
  1259.     short _d = (short)(d);                        \
  1260.     short _e = (short)(e);                        \
  1261.     short _f = (short)(f);                        \
  1262.     short _g = (short)(g);                        \
  1263.                                         \
  1264.     __asm__ volatile                        \
  1265.     ("\
  1266.         movw    %8,sp@-; \
  1267.         movw    %7,sp@-; \
  1268.         movw    %6,sp@-; \
  1269.         movw    %5,sp@-; \
  1270.         movw    %4,sp@-; \
  1271.         movl    %3,sp@-; \
  1272.         movl    %2,sp@-; \
  1273.         movw    %1,sp@-; \
  1274.         trap    #14;    \
  1275.         lea    sp@(20),sp "                    \
  1276.     : "=r"(retvalue)            /* outputs */        \
  1277.     : "g"(n), "r"(_a), "r"(_b),                    \
  1278.       "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */    \
  1279.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1280.     );                                \
  1281.     retvalue;                            \
  1282. })
  1283.  
  1284. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  1285. __extension__                                \
  1286. ({                                    \
  1287.     register long retvalue __asm__("d0");                \
  1288.     long  _a = (long) (a);                        \
  1289.     long  _b = (long) (b);                        \
  1290.     short _c = (short)(c);                        \
  1291.     short _d = (short)(d);                        \
  1292.     short _e = (short)(e);                        \
  1293.     short _f = (short)(f);                        \
  1294.     long  _g = (long) (g);                        \
  1295.     short _h = (short)(h);                        \
  1296.                                         \
  1297.     __asm__ volatile                        \
  1298.     ("\
  1299.         movw    %9,sp@-; \
  1300.         movl    %8,sp@-; \
  1301.         movw    %7,sp@-; \
  1302.         movw    %6,sp@-; \
  1303.         movw    %5,sp@-; \
  1304.         movw    %4,sp@-; \
  1305.         movl    %3,sp@-; \
  1306.         movl    %2,sp@-; \
  1307.         movw    %1,sp@-; \
  1308.         trap    #14;    \
  1309.         lea    sp@(24),sp "                    \
  1310.     : "=r"(retvalue)               /* outputs */    \
  1311.     : "g"(n), "r"(_a), "r"(_b), "r"(_c),                \
  1312.       "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */    \
  1313.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1314.     );                                \
  1315.     retvalue;                            \
  1316. })
  1317.  
  1318. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  1319. __extension__                                \
  1320. ({                                    \
  1321.     register long retvalue __asm__("d0");                \
  1322.     long  _a = (long) (a);                        \
  1323.     long  _b = (long) (b);                        \
  1324.     short _c = (short)(c);                        \
  1325.     short _d = (short)(d);                        \
  1326.     short _e = (short)(e);                        \
  1327.     short _f = (short)(f);                        \
  1328.     short _g = (short)(g);                        \
  1329.     long  _h = (long) (h);                        \
  1330.     short _i = (short)(i);                        \
  1331.                                         \
  1332.     __asm__ volatile                        \
  1333.     ("\
  1334.         movw    %9,sp@-; \
  1335.         movl    %8,sp@-; \
  1336.         movw    %7,sp@-; \
  1337.         movw    %6,sp@-; \
  1338.         movw    %5,sp@-; \
  1339.         movw    %4,sp@-; \
  1340.         movw    %3,sp@-; \
  1341.         movl    %2,sp@-; \
  1342.         movl    %1,sp@-; \
  1343.                 movw    %0,sp@- "                    \
  1344.     :                          /* outputs */    \
  1345.     : "g"(n), "g"(_a), "g"(_b), "g"(_c), "g"(_d),            \
  1346.       "g"(_e), "g"(_f), "g"(_g), "g"(_h), "g"(_i) /* inputs  */    \
  1347.     );                                \
  1348.                                         \
  1349.     __asm__ volatile                        \
  1350.     ("\
  1351.         trap    #14;    \
  1352.         lea    sp@(26),sp "                    \
  1353.     : "=r"(retvalue)            /* outputs */        \
  1354.     :                     /* inputs  */        \
  1355.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1356.     );                                \
  1357.     retvalue;                            \
  1358. })
  1359.  
  1360.  
  1361. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  1362. __extension__                                \
  1363. ({                                    \
  1364.     register long retvalue __asm__("d0");                \
  1365.     short _a = (short)(a);                        \
  1366.     short _b = (short)(b);                        \
  1367.     short _c = (short)(c);                        \
  1368.     short _d = (short)(d);                        \
  1369.     short _e = (short)(e);                        \
  1370.     short _f = (short)(f);                        \
  1371.                                         \
  1372.     __asm__ volatile                        \
  1373.     ("\
  1374.         movw    %7,sp@-; \
  1375.         movw    %6,sp@-; \
  1376.         movw    %5,sp@-; \
  1377.         movw    %4,sp@-; \
  1378.         movw    %3,sp@-; \
  1379.         movw    %2,sp@-; \
  1380.         movw    %1,sp@-; \
  1381.         trap    #14;    \
  1382.         lea    sp@(14),sp "                    \
  1383.     : "=r"(retvalue)            /* outputs */        \
  1384.     : "g"(n), "g"(_a),                        \
  1385.       "g"(_b), "g"(_c), "g"(_d), "g"(_e), "g"(_f)    /* inputs  */    \
  1386.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1387.     );                                \
  1388.     retvalue;                            \
  1389. })
  1390. #else
  1391. #define trap_14_wllwwwww(n, a, b, c, d, e, f, g)            \
  1392. ({                                    \
  1393.     register long retvalue __asm__("d0");                \
  1394.     long  _a = (long) (a);                        \
  1395.     long  _b = (long) (b);                        \
  1396.     short _c = (short)(c);                        \
  1397.     short _d = (short)(d);                        \
  1398.     short _e = (short)(e);                        \
  1399.     short _f = (short)(f);                        \
  1400.     short _g = (short)(g);                        \
  1401.                                         \
  1402.     __asm__ volatile                        \
  1403.     ("\
  1404.         movw    %4,sp@-; \
  1405.         movw    %3,sp@-; \
  1406.         movw    %2,sp@-; \
  1407.         movw    %1,sp@-; \
  1408.         movw    %0,sp@-    "                    \
  1409.     :                          /* outputs */    \
  1410.     : "r"(_c), "r"(_d), "r"(_e), "r"(_f), "r"(_g) /* inputs  */    \
  1411.     );                                \
  1412.                                     \
  1413.     __asm__ volatile                        \
  1414.     ("\
  1415.         movl    %3,sp@-; \
  1416.         movl    %2,sp@-; \
  1417.         movw    %1,sp@-; \
  1418.         trap    #14;    \
  1419.         lea    sp@(20),sp "                    \
  1420.     : "=r"(retvalue)            /* outputs */        \
  1421.     : "g"(n), "r"(_a), "r"(_b)        /* inputs  */        \
  1422.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1423.     );                                \
  1424.     retvalue;                            \
  1425. })
  1426.  
  1427. #define trap_14_wllwwwwlw(n, a, b, c, d, e, f, g, h)            \
  1428. ({                                    \
  1429.     register long retvalue __asm__("d0");                \
  1430.     long  _a = (long) (a);                        \
  1431.     long  _b = (long) (b);                        \
  1432.     short _c = (short)(c);                        \
  1433.     short _d = (short)(d);                        \
  1434.     short _e = (short)(e);                        \
  1435.     short _f = (short)(f);                        \
  1436.     long  _g = (long) (g);                        \
  1437.     short _h = (short)(h);                        \
  1438.                                         \
  1439.     __asm__ volatile                        \
  1440.     ("\
  1441.         movw    %4,sp@-; \
  1442.         movl    %3,sp@-; \
  1443.         movw    %2,sp@-; \
  1444.         movw    %1,sp@-; \
  1445.         movw    %0,sp@- "                    \
  1446.     :                          /* outputs */    \
  1447.     : "r"(_d), "r"(_e), "r"(_f), "r"(_g), "r"(_h) /* inputs  */    \
  1448.     );                                \
  1449.                                         \
  1450.     __asm__ volatile                        \
  1451.     ("\
  1452.         movw    %4,sp@-; \
  1453.         movl    %3,sp@-; \
  1454.         movl    %2,sp@-; \
  1455.         movw    %1,sp@-; \
  1456.         trap    #14;    \
  1457.         lea    sp@(24),sp "                    \
  1458.     : "=r"(retvalue)               /* outputs */    \
  1459.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)        /* inputs  */    \
  1460.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1461.     );                                \
  1462.     retvalue;                            \
  1463. })
  1464.  
  1465. #define trap_14_wllwwwwwlw(n, a, b, c, d, e, f, g, h, i)        \
  1466. ({                                    \
  1467.     register long retvalue __asm__("d0");                \
  1468.     long  _a = (long) (a);                        \
  1469.     long  _b = (long) (b);                        \
  1470.     short _c = (short)(c);                        \
  1471.     short _d = (short)(d);                        \
  1472.     short _e = (short)(e);                        \
  1473.     short _f = (short)(f);                        \
  1474.     short _g = (short)(g);                        \
  1475.     long  _h = (long) (h);                        \
  1476.     short _i = (short)(i);                        \
  1477.                                         \
  1478.     __asm__ volatile                        \
  1479.     ("\
  1480.         movw    %4,sp@-; \
  1481.         movl    %3,sp@-; \
  1482.         movw    %2,sp@-; \
  1483.         movw    %1,sp@-; \
  1484.         movw    %0,sp@- "                    \
  1485.     :                          /* outputs */    \
  1486.     : "r"(_e), "r"(_f), "r"(_g), "r"(_h), "r"(_i) /* inputs  */    \
  1487.     );                                \
  1488.                                     \
  1489.     __asm__ volatile                        \
  1490.     ("\
  1491.         movw    %4,sp@-; \
  1492.         movw    %3,sp@-; \
  1493.         movl    %2,sp@-; \
  1494.         movl    %1,sp@-; \
  1495.                 movw    %0,sp@- "                    \
  1496.     :                         /* outputs */    \
  1497.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  1498.     );                                \
  1499.                                         \
  1500.     __asm__ volatile                        \
  1501.     ("\
  1502.         trap    #14;    \
  1503.         lea    sp@(26),sp "                    \
  1504.     : "=r"(retvalue)            /* outputs */        \
  1505.     :                     /* inputs  */        \
  1506.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1507.     );                                \
  1508.     retvalue;                            \
  1509. })
  1510.  
  1511.  
  1512. #define trap_14_wwwwwww(n, a, b, c, d, e, f)                \
  1513. ({                                    \
  1514.     register long retvalue __asm__("d0");                \
  1515.     short _a = (short)(a);                        \
  1516.     short _b = (short)(b);                        \
  1517.     short _c = (short)(c);                        \
  1518.     short _d = (short)(d);                        \
  1519.     short _e = (short)(e);                        \
  1520.     short _f = (short)(f);                        \
  1521.                                         \
  1522.     __asm__ volatile                        \
  1523.     ("\
  1524.         movw    %4,sp@-; \
  1525.         movw    %3,sp@-; \
  1526.         movw    %2,sp@-; \
  1527.         movw    %1,sp@-; \
  1528.         movw    %0,sp@- "                    \
  1529.     :                            /* outputs */    \
  1530.     : "r"(_b), "r"(_c), "r"(_d), "r"(_e), "r"(_f)    /* inputs  */    \
  1531.     );                                \
  1532.                                     \
  1533.     __asm__ volatile                        \
  1534.     ("\
  1535.         movw    %2,sp@-; \
  1536.         movw    %1,sp@-; \
  1537.         trap    #14;    \
  1538.         lea    sp@(14),sp "                    \
  1539.     : "=r"(retvalue)            /* outputs */        \
  1540.     : "g"(n), "r"(_a)            /* inputs  */        \
  1541.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1542.     );                                \
  1543.     retvalue;                            \
  1544. })
  1545. #endif
  1546.  
  1547. #define trap_14_wlll(n, a, b, c)                    \
  1548. __extension__                                \
  1549. ({                                    \
  1550.     register long retvalue __asm__("d0");                \
  1551.     long  _a = (long) (a);                        \
  1552.     long  _b = (long) (b);                        \
  1553.     long  _c = (long) (c);                        \
  1554.                                         \
  1555.     __asm__ volatile                        \
  1556.     ("\
  1557.         movl    %4,sp@-; \
  1558.         movl    %3,sp@-; \
  1559.         movl    %2,sp@-; \
  1560.         movw    %1,sp@-; \
  1561.         trap    #14;    \
  1562.         lea    sp@(14),sp "                    \
  1563.     : "=r"(retvalue)            /* outputs */        \
  1564.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)     /* inputs  */        \
  1565.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1566.       AND_MEMORY                            \
  1567.     );                                \
  1568.     retvalue;                            \
  1569. })
  1570.  
  1571. #if __GNUC__ > 1
  1572. #define trap_14_wllww(n, a, b, c, d)                    \
  1573. __extension__                                \
  1574. ({                                    \
  1575.     register long retvalue __asm__("d0");                \
  1576.     long  _a = (long) (a);                        \
  1577.     long  _b = (long) (b);                        \
  1578.     short _c = (short)(c);                        \
  1579.     short _d = (short)(d);                        \
  1580.                                         \
  1581.     __asm__ volatile                        \
  1582.     ("\
  1583.         movw    %5,sp@-; \
  1584.         movw    %4,sp@-; \
  1585.         movl    %3,sp@-; \
  1586.         movl    %2,sp@-; \
  1587.         movw    %1,sp@-; \
  1588.         trap    #14;    \
  1589.         lea    sp@(14),sp "                    \
  1590.     : "=r"(retvalue)            /* outputs */        \
  1591.     : "g"(n),                            \
  1592.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1593.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1594.     );                                \
  1595.     retvalue;                            \
  1596. })
  1597.  
  1598. #define trap_14_wwwwl(n, a, b, c, d)                    \
  1599. __extension__                                \
  1600. ({                                    \
  1601.     register long retvalue __asm__("d0");                \
  1602.     short _a = (short)(a);                        \
  1603.     short _b = (short)(b);                        \
  1604.     short _c = (short)(c);                        \
  1605.     long  _d = (long) (d);                        \
  1606.                                         \
  1607.     __asm__ volatile                        \
  1608.     ("\
  1609.         movl    %5,sp@-; \
  1610.         movw    %4,sp@-; \
  1611.         movw    %3,sp@-; \
  1612.         movw    %2,sp@-; \
  1613.         movw    %1,sp@-; \
  1614.         trap    #14;    \
  1615.         lea    sp@(12),sp "                    \
  1616.     : "=r"(retvalue)            /* outputs */        \
  1617.     : "g"(n),                            \
  1618.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */    \
  1619.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1620.     );                                \
  1621.     retvalue;                            \
  1622. })
  1623. #else
  1624. #define trap_14_wllww(n, a, b, c, d)                    \
  1625. ({                                    \
  1626.     register long retvalue __asm__("d0");                \
  1627.     long  _a = (long) (a);                        \
  1628.     long  _b = (long) (b);                        \
  1629.     short _c = (short)(c);                        \
  1630.     short _d = (short)(d);                        \
  1631.                                         \
  1632.     __asm__ volatile                        \
  1633.     ("\
  1634.         movw    %3,sp@-; \
  1635.         movw    %2,sp@-; \
  1636.         movl    %1,sp@-; \
  1637.         movl    %0,sp@- "                    \
  1638.     :                    /* outputs */        \
  1639.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1640.     );                                \
  1641.                                     \
  1642.     __asm__ volatile                        \
  1643.     ("\
  1644.         movw    %1,sp@-; \
  1645.         trap    #14;    \
  1646.         lea    sp@(14),sp "                    \
  1647.     : "=r"(retvalue)            /* outputs */        \
  1648.     : "g"(n)                /* inputs  */        \
  1649.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1650.     );                                \
  1651.     retvalue;                            \
  1652. })
  1653.  
  1654. #define trap_14_wwwwl(n, a, b, c, d)                    \
  1655. ({                                    \
  1656.     register long retvalue __asm__("d0");                \
  1657.     short _a = (short)(a);                        \
  1658.     short _b = (short)(b);                        \
  1659.     short _c = (short)(c);                        \
  1660.     long  _d = (long) (d);                        \
  1661.                                         \
  1662.     __asm__ volatile                        \
  1663.     ("\
  1664.         movl    %3,sp@-; \
  1665.         movw    %2,sp@-; \
  1666.         movw    %1,sp@-; \
  1667.         movw    %0,sp@- "                    \
  1668.     :                        /* outputs */    \
  1669.     : "r"(_a), "r"(_b), "r"(_c), "r"(_d)        /* inputs  */    \
  1670.     );                                \
  1671.                                     \
  1672.     __asm__ volatile                        \
  1673.     ("\
  1674.         movw    %1,sp@-; \
  1675.         trap    #14;    \
  1676.         lea    sp@(12),sp "                    \
  1677.     : "=r"(retvalue)            /* outputs */        \
  1678.     : "g"(n)                /* inputs  */        \
  1679.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1680.     );                                \
  1681.     retvalue;                            \
  1682. })
  1683. #endif
  1684.  
  1685. #define trap_14_wwwl(n, a, b, c)                    \
  1686. __extension__                                \
  1687. ({                                    \
  1688.     register long retvalue __asm__("d0");                \
  1689.     short _a = (short)(a);                        \
  1690.     short _b = (short)(b);                        \
  1691.     long  _c = (long)(c);                        \
  1692.                                         \
  1693.     __asm__ volatile                        \
  1694.     ("                                \
  1695.         movl    %4,sp@-;                    \
  1696.         movw    %3,sp@-;                    \
  1697.         movw    %2,sp@-;                    \
  1698.         movw    %1,sp@-;                    \
  1699.         trap    #14;                        \
  1700.         lea    sp@(10),sp "                    \
  1701.     : "=r"(retvalue)            /* outputs */        \
  1702.     : "g"(n), "r"(_a), "r"(_b), "r"(_c)    /* inputs  */        \
  1703.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1704.       AND_MEMORY                            \
  1705.     );                                \
  1706.     retvalue;                            \
  1707. })
  1708.  
  1709. #if __GNUC__ > 1
  1710. #define trap_14_wlwlw(n, a, b, c, d)                    \
  1711. __extension__                                \
  1712. ({                                    \
  1713.     register long retvalue __asm__("d0");                \
  1714.     long  _a = (long) (a);                        \
  1715.     short _b = (short)(b);                        \
  1716.     long  _c = (long) (c);                        \
  1717.     short _d = (short)(d);                        \
  1718.                                         \
  1719.     __asm__ volatile                        \
  1720.     ("\
  1721.         movw    %5,sp@-; \
  1722.         movl    %4,sp@-; \
  1723.         movw    %3,sp@-; \
  1724.         movl    %2,sp@-; \
  1725.         movw    %1,sp@-; \
  1726.         trap    #14;    \
  1727.         lea    sp@(14),sp "                    \
  1728.     : "=r"(retvalue)            /* outputs */        \
  1729.     : "g"(n),                            \
  1730.       "r"(_a), "r"(_b), "r"(_c), "r"(_d)    /* inputs  */        \
  1731.     : "d0", "d1", "d2", "a0", "a1", "a2", "memory"            \
  1732.     );                                \
  1733.     retvalue;                            \
  1734. })
  1735. #else
  1736. #define trap_14_wlwlw(n, a, b, c, d)                    \
  1737. ({                                    \
  1738.     register long retvalue __asm__("d0");                \
  1739.     long  _a = (long) (a);                        \
  1740.     short _b = (short)(b);                        \
  1741.     long  _c = (long) (c);                        \
  1742.     short _d = (short)(d);                        \
  1743.                                         \
  1744.     __asm__ volatile                        \
  1745.     ("\
  1746.         movw    %4,sp@-; \
  1747.         movl    %3,sp@-; \
  1748.         movw    %2,sp@-; \
  1749.         movl    %1,sp@-; \
  1750.         movw    %0,sp@-;" \
  1751.     :                    /* outputs */        \
  1752.     : "g"(n), "r"(_a), "r"(_b), "r"(_c), "r"(_d) /* inputs  */    \
  1753.     );                                \
  1754.                                     \
  1755.     __asm__ volatile                        \
  1756.     ("\
  1757.         trap    #14;    \
  1758.         lea    sp@(14),sp "                    \
  1759.     : "=r"(retvalue)            /* outputs */        \
  1760.     :                    /* inputs  */        \
  1761.     : "d0", "d1", "d2", "a0", "a1", "a2"    /* clobbered regs */    \
  1762.     );                                \
  1763.     retvalue;                            \
  1764. })
  1765. #endif
  1766.  
  1767. #else /* __GNUC_INLINE__ */
  1768.  
  1769. # ifndef __MSHORT__
  1770. #  define _TRAP_X_
  1771. # else
  1772. #  ifdef __GNUC__
  1773. #   ifndef __MINT__
  1774. #    define _TRAP_X_
  1775. #   endif
  1776. #  endif
  1777. # endif /* !__MSHORT__ */
  1778.  
  1779. # ifdef _TRAP_X_
  1780. /* if inlines are not allowed, then declare things external */
  1781. __EXTERN long trap_1_w __PROTO((short n));
  1782. __EXTERN long trap_1_ww __PROTO((short n, short a));
  1783. __EXTERN long trap_1_wl __PROTO((short n, long a));
  1784. __EXTERN long trap_1_wlw __PROTO((short n, long a, short b));
  1785. __EXTERN long trap_1_wwll __PROTO((short n, short a, long b, long c));
  1786. __EXTERN long trap_1_wlww __PROTO((short n, long a, short b, short c));
  1787. __EXTERN long trap_1_www __PROTO((short n, short a, short b));
  1788. __EXTERN long trap_1_wll __PROTO((short n, long a, long b));
  1789. __EXTERN long trap_1_wwlll __PROTO((short n, short a, long b, long c, long d));
  1790. __EXTERN long trap_1_wwwll __PROTO((short n, short a, short b, long c, long d));
  1791. __EXTERN long trap_13_wl __PROTO((short n, long a));
  1792. __EXTERN long trap_13_w __PROTO((short n));
  1793. __EXTERN long trap_13_ww __PROTO((short n, short a));
  1794. __EXTERN long trap_13_www __PROTO((short n, short a, short b));
  1795. __EXTERN long trap_13_wwlwww __PROTO((short n, short a, long b, short c, short d, short e));
  1796. __EXTERN long trap_13_wwl __PROTO((short n, short a, long b));
  1797. __EXTERN long trap_14_wwl __PROTO((short n, short a, long b));
  1798. __EXTERN long trap_14_wwll __PROTO((short n, short a, long b, long c));
  1799. __EXTERN long trap_14_ww __PROTO((short n, short a));
  1800. __EXTERN long trap_14_w __PROTO((short n));
  1801. __EXTERN long trap_14_wllw __PROTO((short n, long a, long b, short c));
  1802. __EXTERN long trap_14_wl __PROTO((short n, long a));
  1803. __EXTERN long trap_14_www __PROTO((short n, short a, short b));
  1804. __EXTERN long trap_14_wllwwwww __PROTO((short n, long a, long b, short c, short d, short e, short f, short g));
  1805. __EXTERN long trap_14_wllwwwwlw __PROTO((short n, long a, long b, short c, short d, short e, short f, long g, short h));
  1806. __EXTERN long trap_14_wllwwwwwlw __PROTO((short n, long a, long b, short c, short d, short e, short f, short g, long h, short i));
  1807. __EXTERN long trap_14_wwwwwww __PROTO((short n, short a, short b, short c, short d, short e, short f));
  1808. __EXTERN long trap_14_wlll __PROTO((short n, long a, long b, long c));
  1809. __EXTERN long trap_14_wllww __PROTO((short n, long a, long b, short c, short d));
  1810. __EXTERN long trap_14_wwwwl __PROTO((short n, short a, short b, short c, long d));
  1811. __EXTERN long trap_14_wwwl __PROTO((short n, short a, short b, long c));
  1812. __EXTERN long trap_14_wlwlw __PROTO((short n, long a, short b, long c, short d));
  1813.  
  1814. # else /* __TRAP_X__ */
  1815.  
  1816. __EXTERN long gemdos    __PROTO((short, ...));
  1817. __EXTERN long bios    __PROTO((short, ...));
  1818. __EXTERN long xbios    __PROTO((short, ...));
  1819.  
  1820. #define trap_1_w    gemdos
  1821. #define trap_1_ww    gemdos
  1822. #define trap_1_wl    gemdos
  1823. #define trap_1_wlw    gemdos
  1824. #define trap_1_www    gemdos
  1825. #define trap_1_wll    gemdos
  1826. #define trap_1_wwll    gemdos
  1827. #define trap_1_wlww    gemdos
  1828. #define trap_1_wwlll    gemdos
  1829. #define trap_1_wwwll    gemdos
  1830.  
  1831. #define trap_13_w    bios
  1832. #define trap_13_ww    bios
  1833. #define trap_13_wl    bios
  1834. #define trap_13_www    bios
  1835. #define trap_13_wwl    bios
  1836. #define trap_13_wwlwww    bios
  1837.  
  1838. #define trap_14_w    xbios
  1839. #define trap_14_ww    xbios
  1840. #define trap_14_wl    xbios
  1841. #define trap_14_www    xbios
  1842. #define trap_14_wwl    xbios
  1843. #define trap_14_wwll    xbios
  1844. #define trap_14_wllw    xbios
  1845. #define trap_14_wlll    xbios
  1846. #define trap_14_wwwl    xbios
  1847. #define trap_14_wwwwl    xbios
  1848. #define trap_14_wllww    xbios
  1849. #define trap_14_wwwwwww    xbios
  1850. #define trap_14_wllwwwww    xbios
  1851. #define trap_14_wllwwwwlw    xbios
  1852. #define trap_14_wllwwwwwlw    xbios
  1853. #define trap_14_wlwlw    xbios
  1854.  
  1855. # endif /* _TRAP_X_ */
  1856.  
  1857. #endif /* __GNUC_INLINE__ */
  1858.  
  1859.  
  1860. /* DEFINITIONS FOR OS FUNCTIONS */
  1861.  
  1862. /*
  1863.  *     GEMDOS  (trap1)
  1864.  */
  1865. #define           Pterm0()                                      \
  1866.        (void)trap_1_w((short)(0x00))
  1867. #define           Cconin()                               \
  1868.        (long)trap_1_w((short)(0x01))
  1869. #define           Cconout(c)                           \
  1870.        (void)trap_1_ww((short)(0x02),(short)(c))
  1871. #define           Cauxin()                               \
  1872.        (long)trap_1_w((short)(0x03))
  1873. #define           Cauxout(c)                           \
  1874.        (void)trap_1_ww((short)(0x04),(short)(c))
  1875. #define           Cprnout(c)                           \
  1876.        (void)trap_1_ww((short)(0x05),(short)(c))
  1877. #define           Crawio(data)                           \
  1878.        (long)trap_1_ww((short)(0x06),(short)(data))
  1879. #define           Crawcin()                           \
  1880.        (long)trap_1_w((short)(0x07))
  1881. #define           Cnecin()                               \
  1882.        (long)trap_1_w((short)(0x08))
  1883. #define           Cconws(s)                           \
  1884.        (void)trap_1_wl((short)(0x09),(long)(s))
  1885. #define           Cconrs(buf)                           \
  1886.        (void)trap_1_wl((short)(0x0A),(long)(buf))
  1887. #define           Cconis()                               \
  1888.        (short)trap_1_w((short)(0x0B))
  1889. #define           Dsetdrv(d)                           \
  1890.        (long)trap_1_ww((short)(0x0E),(short)(d))
  1891. #define           Cconos()                               \
  1892.        (short)trap_1_w((short)(0x10))
  1893. #define           Cprnos()                               \
  1894.        (short)trap_1_w((short)(0x11))
  1895. #define           Cauxis()                               \
  1896.        (short)trap_1_w((short)(0x12))
  1897. #define           Cauxos()                               \
  1898.        (short)trap_1_w((short)(0x13))
  1899. #define           Dgetdrv()                           \
  1900.        (short)trap_1_w((short)(0x19))
  1901. #define           Fsetdta(dta)                           \
  1902.        (void)trap_1_wl((short)(0x1A),(long)(dta))
  1903.  
  1904. /*
  1905.  * The next binding is not quite right if used in another than the usual ways:
  1906.  *    1. Super(1L) from either user or supervisor mode
  1907.  *    2. ret = Super(0L) from user mode and after this Super(ret) from
  1908.  *       supervisor mode
  1909.  * We get the following situations (usp, ssp relative to the start of Super):
  1910.  *    Parameter    Userstack    Superstack    Calling Mode    ret
  1911.  *       1L           usp           ssp            user     0L
  1912.  *       1L           usp           ssp         supervisor    -1L
  1913.  *       0L          usp-6           usp            user    ssp
  1914.  *       0L           ssp          ssp-6         supervisor   ssp-6
  1915.  *      ptr          usp-6          ptr+6            user    ssp
  1916.  *      ptr          usp+6           ptr         supervisor     sr
  1917.  * The usual C-bindings are safe only because the "unlk a6" is compensating
  1918.  * the errors when you invoke this function. In this binding the "unlk a6" at
  1919.  * the end of the calling function compensates the error made in sequence 2
  1920.  * above (the usp is 6 to low after the first call which is not corrected by
  1921.  * the second call).
  1922.  */
  1923. #define           Super(ptr)                           \
  1924.        (long)trap_1_wl((short)(0x20),(long)(ptr))
  1925.     /* Tos 1.4: Super(1L) : rets -1L if in super mode, 0L otherwise */
  1926. #define           Tgetdate()                           \
  1927.        (short)trap_1_w((short)(0x2A))
  1928. #define           Tsetdate(date)                           \
  1929.        (long)trap_1_ww((short)(0x2B),(short)(date))
  1930. #define           Tgettime()                           \
  1931.        (short)trap_1_w((short)(0x2C))
  1932. #define           Tsettime(time)                           \
  1933.        (long)trap_1_ww((short)(0x2D),(short)(time))
  1934. #define           Fgetdta()                           \
  1935.        (_DTA *)trap_1_w((short)(0x2F))
  1936. #define           Sversion()                           \
  1937.        (short)trap_1_w((short)(0x30))
  1938. #define           Ptermres(save,rv)                       \
  1939.        (void)trap_1_wlw((short)(0x31),(long)(save),(short)(rv))
  1940. #define           Dfree(buf,d)                           \
  1941.        (long)trap_1_wlw((short)(0x36),(long)(buf),(short)(d))
  1942. #define           Dcreate(path)                           \
  1943.        (short)trap_1_wl((short)(0x39),(long)(path))
  1944. #define           Ddelete(path)                           \
  1945.        (long)trap_1_wl((short)(0x3A),(long)(path))
  1946. #define           Dsetpath(path)                           \
  1947.        (long)trap_1_wl((short)(0x3B),(long)(path))
  1948. #define           Fcreate(fn,mode)                           \
  1949.        (long)trap_1_wlw((short)(0x3C),(long)(fn),(short)(mode))
  1950. #define           Fopen(fn,mode)                           \
  1951.        (long)trap_1_wlw((short)(0x3D),(long)(fn),(short)(mode))
  1952. #define           Fclose(handle)                           \
  1953.        (long)trap_1_ww((short)(0x3E),(short)(handle))
  1954. #define           Fread(handle,cnt,buf)                       \
  1955.        (long)trap_1_wwll((short)(0x3F),(short)(handle),           \
  1956.              (long)(cnt),(long)(buf))
  1957. #define           Fwrite(handle,cnt,buf)                       \
  1958.        (long)trap_1_wwll((short)(0x40),(short)(handle),           \
  1959.              (long)(cnt),(long)(buf))
  1960. #define           Fdelete(fn)                           \
  1961.        (long)trap_1_wl((short)(0x41),(long)(fn))
  1962. #define           Fseek(where,handle,how)                       \
  1963.        (long)trap_1_wlww((short)(0x42),(long)(where),           \
  1964.              (short)(handle),(short)(how))
  1965. #define           Fattrib(fn,rwflag,attr)                       \
  1966.        (short)trap_1_wlww((short)(0x43),(long)(fn),           \
  1967.               (short)(rwflag),(short)(attr))
  1968. #define           Fdup(handle)                           \
  1969.        (long)trap_1_ww((short)(0x45),(short)(handle))
  1970. #define           Fforce(Hstd,Hnew)                       \
  1971.        (long)trap_1_www((short)(0x46),(short)(Hstd),(short)(Hnew))
  1972. #define           Dgetpath(buf,d)                           \
  1973.        (long)trap_1_wlw((short)(0x47),(long)(buf),(short)(d))
  1974. #define           Malloc(size)                           \
  1975.        (long)trap_1_wl((short)(0x48),(long)(size))
  1976. #define           Mfree(ptr)                           \
  1977.        (long)trap_1_wl((short)(0x49),(long)(ptr))
  1978. #define           Mshrink(ptr,size)                       \
  1979.        (long)trap_1_wwll((short)(0x4A),(short)0,(long)(ptr),(long)(size))
  1980. #define           Pexec(mode,prog,tail,env)               \
  1981.        (long)trap_1_wwlll((short)(0x4B),(short)(mode),(long)(prog),   \
  1982.                (long)(tail),(long)(env))
  1983. #define           Pterm(rv)                           \
  1984.        (void)trap_1_ww((short)(0x4C),(short)(rv))
  1985. #define           Fsfirst(filespec,attr)                       \
  1986.        (long)trap_1_wlw((short)(0x4E),(long)(filespec),(short)(attr))
  1987. #define           Fsnext()                               \
  1988.        (long)trap_1_w((short)(0x4F))
  1989. #define           Frename(zero,old,new)                       \
  1990.        (short)trap_1_wwll((short)(0x56),(short)(zero),           \
  1991.               (long)(old),(long)(new))
  1992. #define           Fdatime(timeptr,handle,rwflag)                   \
  1993.        (long)trap_1_wlww((short)(0x57),(long)(timeptr),           \
  1994.              (short)(handle),(short)(rwflag))
  1995. #define           Flock(handle,mode,start,length)                   \
  1996.        (long)trap_1_wwwll((short)(0x5C),(short)(handle),       \
  1997.               (short)(mode),(long)(start),(long)(length))
  1998.  
  1999. /*
  2000.  *     BIOS    (trap13)
  2001.  */
  2002. #define Getmpb(ptr)                           \
  2003.        (void)trap_13_wl((short)(0x00),(long)(ptr))
  2004. #define           Bconstat(dev)                           \
  2005.        (short)trap_13_ww((short)(0x01),(short)(dev))
  2006. #define           Bconin(dev)                           \
  2007.        (long)trap_13_ww((short)(0x02),(short)(dev))
  2008. #define           Bconout(dev,c)                           \
  2009.        (long)trap_13_www((short)(0x03),(short)(dev),(short)((c) & 0xFF))
  2010. /* since AHDI 3.1 there is a new call to Rwabs with one more parameter */
  2011. #define           Rwabs(rwflag,buf,n,sector,d)            \
  2012.        (long)trap_13_wwlwww((short)(0x04),(short)(rwflag),(long)(buf), \
  2013.                  (short)(n),(short)(sector),(short)(d))
  2014. #define           Setexc(vnum,vptr)                       \
  2015.        (void (*) __PROTO((void)))trap_13_wwl((short)(0x05),(short)(vnum),(long)(vptr))
  2016. #define           Tickcal()                           \
  2017.        (long)trap_13_w((short)(0x06))
  2018. #define           Getbpb(d)                           \
  2019.        (void *)trap_13_ww((short)(0x07),(short)(d))
  2020. #define           Bcostat(dev)                           \
  2021.        (short)trap_13_ww((short)(0x08),(short)(dev))
  2022. #define           Mediach(dev)                           \
  2023.        (short)trap_13_ww((short)(0x09),(short)(dev))
  2024. #define           Drvmap()                               \
  2025.        (long)trap_13_w((short)(0x0A))
  2026. #define           Kbshift(data)                           \
  2027.        (long)trap_13_ww((short)(0x0B),(short)(data))
  2028. #define           Getshift()                           \
  2029.     Kbshift(-1)
  2030.  
  2031.  
  2032. /*
  2033.  *     XBIOS   (trap14)
  2034.  */
  2035.  
  2036. #define           Initmous(type,param,vptr)                   \
  2037.        (void)trap_14_wwll((short)(0x00),(short)(type),           \
  2038.               (long)(param),(long)(vptr))
  2039. #define Ssbrk(size)                           \
  2040.        (void *)trap_14_ww((short)(0x01),(short)(size))
  2041. #define           Physbase()                           \
  2042.        (void *)trap_14_w((short)(0x02))
  2043. #define           Logbase()                           \
  2044.        (void *)trap_14_w((short)(0x03))
  2045. #define           Getrez()                               \
  2046.        (short)trap_14_w((short)(0x04))
  2047. #define           Setscreen(lscrn,pscrn,rez)                   \
  2048.        (void)trap_14_wllw((short)(0x05),(long)(lscrn),(long)(pscrn), \
  2049.               (short)(rez))
  2050. #define           Setpalette(palptr)                       \
  2051.        (void)trap_14_wl((short)(0x06),(long)(palptr))
  2052. #define           Setcolor(colornum,mixture)                   \
  2053.        (short)trap_14_www((short)(0x07),(short)(colornum),(short)(mixture))
  2054. #define           Floprd(buf,x,d,sect,trk,side,n)                   \
  2055.        (short)trap_14_wllwwwww((short)(0x08),(long)(buf),(long)(x), \
  2056.      (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  2057. #define           Flopwr(buf,x,d,sect,trk,side,n)                   \
  2058.        (short)trap_14_wllwwwww((short)(0x09),(long)(buf),(long)(x), \
  2059.            (short)(d),(short)(sect),(short)(trk),(short)(side),(short)(n))
  2060. #define           Flopfmt(buf,x,d,spt,t,sd,i,m,v)               \
  2061.        (short)trap_14_wllwwwwwlw((short)(0x0A),(long)(buf),(long)(x), \
  2062.       (short)(d),(short)(spt),(short)(t),(short)(sd),(short)(i),  \
  2063.       (long)(m),(short)(v))
  2064. #define           Midiws(cnt,ptr)                           \
  2065.        (void)trap_14_wwl((short)(0x0C),(short)(cnt),(long)(ptr))
  2066. #define           Mfpint(vnum,vptr)                       \
  2067.        (void)trap_14_wwl((short)(0x0D),(short)(vnum),(long)(vptr))
  2068. #define           Iorec(ioDEV)                           \
  2069.        (void *)trap_14_ww((short)(0x0E),(short)(ioDEV))
  2070. #define           Rsconf(baud,flow,uc,rs,ts,sc)                   \
  2071.        (long)trap_14_wwwwwww((short)(0x0F),(short)(baud),(short)(flow), \
  2072.               (short)(uc),(short)(rs),(short)(ts),(short)(sc))
  2073.     /* ret old val: MSB -> ucr:8, rsr:8, tsr:8, scr:8 <- LSB */
  2074. #define           Keytbl(nrml,shft,caps)                       \
  2075.        (void *)trap_14_wlll((short)(0x10),(long)(nrml), \
  2076.                 (long)(shft),(long)(caps))
  2077. #define           Random()                               \
  2078.        (long)trap_14_w((short)(0x11))
  2079. #define           Protobt(buf,serial,dsktyp,exec)                   \
  2080.        (void)trap_14_wllww((short)(0x12),(long)(buf),(long)(serial), \
  2081.                (short)(dsktyp),(short)(exec))
  2082. #define           Flopver(buf,x,d,sect,trk,sd,n)                   \
  2083.        (short)trap_14_wllwwwww((short)(0x13),(long)(buf),(long)(x),(short)(d),\
  2084.            (short)(sect),(short)(trk),(short)(sd),(short)(n))
  2085. #define           Scrdmp()                               \
  2086.        (void)trap_14_w((short)(0x14))
  2087. #define           Cursconf(rate,attr)                       \
  2088.        (short)trap_14_www((short)(0x15),(short)(rate),(short)(attr))
  2089. #define           Settime(time)                           \
  2090.        (void)trap_14_wl((short)(0x16),(long)(time))
  2091. #define           Gettime()                           \
  2092.        (long)trap_14_w((short)(0x17))
  2093. #define           Bioskeys()                           \
  2094.        (void)trap_14_w((short)(0x18))
  2095. #define           Ikbdws(len_minus1,ptr)                       \
  2096.        (void)trap_14_wwl((short)(0x19),(short)(len_minus1),(long)(ptr))
  2097. #define           Jdisint(vnum)                           \
  2098.        (void)trap_14_ww((short)(0x1A),(short)(vnum))
  2099. #define           Jenabint(vnum)                           \
  2100.        (void)trap_14_ww((short)(0x1B),(short)(vnum))
  2101. #define           Giaccess(data,reg)                       \
  2102.        (short)trap_14_www((short)(0x1C),(short)(data),(short)(reg))
  2103. #define           Offgibit(ormask)                           \
  2104.        (void)trap_14_ww((short)(0x1D),(short)(ormask))
  2105. #define           Ongibit(andmask)                           \
  2106.        (void)trap_14_ww((short)(0x1E),(short)(andmask))
  2107. #define           Xbtimer(timer,ctrl,data,vptr)                   \
  2108.        (void)trap_14_wwwwl((short)(0x1F),(short)(timer),(short)(ctrl), \
  2109.                (short)(data),(long)(vptr))
  2110. #define           Dosound(ptr)                           \
  2111.        (void)trap_14_wl((short)(0x20),(long)(ptr))
  2112. #define           Setprt(config)                           \
  2113.        (short)trap_14_ww((short)(0x21),(short)(config))
  2114. #define           Kbdvbase()                           \
  2115.        (_KBDVECS*)trap_14_w((short)(0x22))
  2116. #define           Kbrate(delay,reprate)                       \
  2117.        (short)trap_14_www((short)(0x23),(short)(delay),(short)(reprate))
  2118. #define           Prtblk(pblkptr)                           \
  2119.        (void)trap_14_wl((short)(0x24),(long)(pblkptr)) /* obsolete ? */
  2120. #define           Vsync()                               \
  2121.        (void)trap_14_w((short)(0x25))
  2122. #define           Supexec(funcptr)                           \
  2123.        (long)trap_14_wl((short)(0x26),(long)(funcptr))
  2124. #define           Floprate(drive,rate)                       \
  2125.        (short)trap_14_www((short)(0x29),(short)(drive),(short)(rate))
  2126. #define           Blitmode(flag)                           \
  2127.        (short)trap_14_ww((short)(0x40),(short)(flag))
  2128. /*
  2129.  * Flag:
  2130.  *  -1: get config
  2131.  * !-1: set config    previous config returned
  2132.  *    bit
  2133.  *     0    0 blit mode soft    1 blit mode hardware
  2134.  *     1    0 no blitter        1 blitter present
  2135.  *    2..14   reserved
  2136.  *     15    must be zero on set/returned as zero
  2137.  * blitmode (bit 0) forced to soft if no blitter(bit 1 == 0).
  2138.  */
  2139.  
  2140. /*
  2141.  * extensions for TT TOS
  2142.  */
  2143.  
  2144. #define         Mxalloc(amt,flag)                    \
  2145.     (long)trap_1_wlw((short)(0x44),(long)(amt),(short)(flag))
  2146. #define        Maddalt(start,size)                    \
  2147.     (long)trap_1_wll((short)(0x14),(long)(start),(long)(size))
  2148.  
  2149. #define         EsetShift(mode)                        \
  2150.     (void)trap_14_ww((short)(80),(short)mode)
  2151. #define         EgetShift()                        \
  2152.     (short)trap_14_w((short)(81))
  2153. #define         EsetBank(bank)                        \
  2154.     (short)trap_14_ww((short)(82),(short)bank)
  2155. #define         EsetColor(num,val)                    \
  2156.     (short)trap_14_www((short)(83),(short)num,(short)val)
  2157. #define         EsetPalette(start,count,ptr)                \
  2158.     (void)trap_14_wwwl((short)(84),(short)start,(short)count,(long)ptr)
  2159. #define         EgetPalette(start,count,ptr)                \
  2160.     (void)trap_14_wwwl((short)(85),(short)start,(short)count,(long)ptr)
  2161. #define         EsetGray(mode)                        \
  2162.     (short)trap_14_ww((short)(86),(short)mode)
  2163. #define         EsetSmear(mode)                        \
  2164.     (short)trap_14_ww((short)(87),(short)mode)
  2165.  
  2166. #define        DMAread(sector,count,buffer,devno)            \
  2167.     (long)trap_14_wlwlw((short)0x2a,(long)sector,(short)count,(long)buffer, \
  2168.                 (short)devno)
  2169. #define        DMAwrite(sector,count,buffer,devno)            \
  2170.     (long)trap_14_wlwlw((short)0x2b,(long)sector,(short)count,(long)buffer, \
  2171.             (short)devno)
  2172. #define        Bconmap(dev)                        \
  2173.     (long)trap_14_ww((short)0x2c,(short)(dev))
  2174. #define        NVMaccess(op,start,count,buf)                \
  2175.     (short)trap_14_wwwwl((short)0x2e,(short)op,(short)start,(short)count, \
  2176.             (long)buf)
  2177.  
  2178. /*  Wake-up call for ST BOOK -- takes date/time pair in DOS format. */
  2179.  
  2180. #define           Waketime(w_date, w_time)                    \
  2181.        (void)trap_14_www((short)(0x2f),(unsigned short)(w_date),    \
  2182.                        (unsigned short)(w_time))
  2183.  
  2184. #endif /* __LATTICE__ */
  2185. #endif /* __TURBOC__ */
  2186.  
  2187. #ifdef __cplusplus
  2188. }
  2189. #endif
  2190.  
  2191. #endif /* _OSBIND_H */
  2192.